home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / shells / bashsrc.zoo / bashline.c < prev    next >
C/C++ Source or Header  |  1991-06-05  |  19KB  |  708 lines
  1. /* bashline.c -- Bash's interface to the readline library. */
  2.  
  3. /* Copyright (C) 1989 Free Software Foundation, Inc.
  4.  
  5. This file is part of GNU Bash, the Bourne Again SHell.
  6.  
  7. Bash is free software; you can redistribute it and/or modify it under
  8. the terms of the GNU General Public License as published by the Free
  9. Software Foundation; either version 1, or (at your option) any later
  10. version.
  11.  
  12. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  13. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15. for more details.
  16.  
  17. You should have received a copy of the GNU General Public License along
  18. with Bash; see the file COPYING.  If not, write to the Free Software
  19. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21. #include <stdio.h>
  22. #include <readline/readline.h>
  23. #include "config.h"
  24. #include "general.h"
  25. #include "variables.h"
  26. #include "builtins.h"
  27. #include "quit.h"
  28.  
  29. /* Called once from parse.y if we are going to use readline. */
  30. initialize_readline ()
  31. {
  32.   char **attempt_shell_completion (), *bash_tilde_expand ();
  33.   int shell_expand_line (), insert_last_arg (), bash_symbolic_link_hook ();
  34.   char *get_string_value ();
  35.  
  36.   rl_terminal_name = get_string_value ("TERM");
  37.   rl_instream = stdin, rl_outstream = stderr;
  38.   rl_special_prefixes = "$@%";
  39.  
  40.   /* Bind up our special shell functions. */
  41.   rl_add_defun ("shell-expand-line", shell_expand_line, META(CTRL('E')));
  42.   rl_add_defun ("insert-last-argument", insert_last_arg, META('.'));
  43.   rl_add_defun ("insert-last-argument", insert_last_arg, META('_'));
  44.  
  45.   /* Tell the completer that we want a crack first. */
  46.   rl_attempted_completion_function = (Function *)attempt_shell_completion;
  47.  
  48.   /* Tell the tilde expander that we want a crack if it fails. */
  49.   rl_tilde_expander = (Function *)bash_tilde_expand;
  50.  
  51.   /* Tell the completer that we might want to follow symbolic links. */
  52.   rl_symbolic_link_hook = (Function *)bash_symbolic_link_hook;
  53.  
  54.   /* And don't forget to allow conditional parsing of the ~/.inputrc
  55.      file. */
  56.   rl_readline_name = "Bash";
  57. }
  58.  
  59. /* Contains the line to push into readline. */
  60. char *push_to_readline = (char *)NULL;
  61.  
  62. /* Push the contents of push_to_readline into the
  63.    readline buffer. */
  64. bash_push_line ()
  65. {
  66.   if (push_to_readline)
  67.     {
  68.       rl_insert_text (push_to_readline);
  69.       free (push_to_readline);
  70.       push_to_readline = (char *)NULL;
  71.     }
  72. }
  73.  
  74. /* Call this to set the initial text for the next line to read
  75.    from readline. */
  76. bash_re_edit (line)
  77.      char *line;
  78. {
  79.   if (push_to_readline)
  80.     free (push_to_readline);
  81.  
  82.   push_to_readline = savestring (line);
  83.   rl_startup_hook = bash_push_line;
  84. }
  85.  
  86. /* **************************************************************** */
  87. /*                                    */
  88. /*                 Readline Stuff                  */
  89. /*                                        */
  90. /* **************************************************************** */
  91.  
  92. /* If the user requests hostname completion, then simply build a list
  93.    of hosts, and complete from that forever more. */
  94. #ifndef ETCHOSTS
  95. #define ETCHOSTS "/etc/hosts"
  96. #endif
  97.  
  98. /* The kept list of hostnames. */
  99. static char **hostname_list = (char **)NULL;
  100.  
  101. /* The physical size of the above list. */
  102. static int hostname_list_size = 0;
  103.  
  104. /* The length of the above list. */
  105. static int hostname_list_length = 0;
  106.  
  107. /* Whether or not HOSTNAME_LIST has been initialized. */
  108. int hostname_list_initialized = 0;
  109.  
  110. /* Non-zero means that HOSTNAME_LIST needs to be sorted. */
  111. static int hostname_list_needs_sorting = 0;
  112.  
  113. /* Initialize the hostname completion table. */
  114. initialize_hostname_list ()
  115. {
  116.   char *temp = get_string_value ("hostname_completion_file");
  117.  
  118.   if (!temp)
  119.     temp = ETCHOSTS;
  120.  
  121.   snarf_hosts_from_file (temp);
  122.   sort_hostname_list ();
  123.   if (hostname_list)
  124.     hostname_list_initialized++;
  125. }
  126.  
  127. /* Add NAME to the list of hosts. */
  128. add_host_name (name)
  129.      char *name;
  130. {
  131.   if (hostname_list_length + 2 > hostname_list_size)
  132.     {
  133.       if (!hostname_list)
  134.     hostname_list = (char **)xmalloc (sizeof (char *));
  135.  
  136.       hostname_list = (char **)
  137.     xrealloc (hostname_list,
  138.           (1 + (hostname_list_size += 100)) * sizeof (char *));
  139.     }
  140.  
  141.   hostname_list[hostname_list_length] = savestring (name);
  142.   hostname_list[++hostname_list_length] = (char *)NULL;
  143.   hostname_list_needs_sorting++;
  144. }
  145.  
  146. /* After you have added some names, you should sort the list of names. */
  147. sort_hostname_list ()
  148. {
  149.   extern int qsort_string_compare ();
  150.   if (hostname_list_needs_sorting && hostname_list)
  151.     qsort (hostname_list, hostname_list_length,
  152.        sizeof (char *), qsort_string_compare);
  153.   hostname_list_needs_sorting = 0;
  154. }
  155.  
  156. #define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))
  157.  
  158. snarf_hosts_from_file (filename)
  159.      char *filename;
  160. {
  161.   FILE *file = fopen (filename, "r");
  162.   char *temp, buffer[256], name[256];
  163.   register int i, start;
  164.  
  165.   if (!file)
  166.     return;
  167.  
  168.   while (temp = fgets (buffer, 255, file))
  169.     {
  170.       /* Skip to first character. */
  171.       for (i = 0; buffer[i] && cr_whitespace (buffer[i]); i++);
  172.  
  173.       /* If comment, ignore. */
  174.       if (buffer[i] ==  '#')
  175.     continue;
  176.  
  177.       /* Skip internet address. */
  178.       for (; buffer[i] && !cr_whitespace (buffer[i]); i++);
  179.  
  180.       /* Gobble up names.  Each name is separated with whitespace. */
  181.       while (buffer[i] && buffer[i] != '#')
  182.     {
  183.       for (; i && cr_whitespace (buffer[i]); i++);
  184.       if (buffer[i] ==  '#')
  185.         continue;
  186.       for (start = i; buffer[i] && !cr_whitespace (buffer[i]); i++);
  187.       if ((i - start) == 0)
  188.         continue;
  189.       strncpy (name, buffer + start, i - start);
  190.       name[i - start] = '\0';
  191.       add_host_name (name);
  192.     }
  193.     }
  194.   fclose (file);
  195. }
  196.  
  197. /* Return a NULL terminated list of hostnames which begin with TEXT.
  198.    Initialize the hostname list the first time if neccessary.
  199.    The array is malloc ()'ed, but not the individual strings. */
  200. char **
  201. hostnames_matching (text)
  202.      char *text;
  203. {
  204.   register int i, len = strlen (text);
  205.   register int begin, end;
  206.   int last_search = -1;
  207.   char **result = (char **)NULL;
  208.  
  209.   if (!hostname_list_initialized)
  210.     {
  211.       initialize_hostname_list ();
  212.  
  213.       if (!hostname_list_initialized)
  214.     return ((char **)NULL);
  215.     }
  216.  
  217.   sort_hostname_list ();
  218.  
  219.   /* The list is sorted.  Do a binary search on it for the first character
  220.      in TEXT, and then grovel the names of interest. */
  221.   begin = 0; end = hostname_list_length;
  222.  
  223.   /* Special case.  If TEXT consists of nothing, then the whole list is
  224.      what is desired. */
  225.   if (!*text)
  226.     {
  227.       result = (char **)xmalloc ((1 + hostname_list_length) * sizeof (char *));
  228.       for (i = 0; i < hostname_list_length; i++)
  229.     result[i] = hostname_list[i];
  230.       result[i] = (char *)NULL;
  231.       return (result);
  232.     }
  233.  
  234.   /* Scan until found, or failure. */
  235.   while (end != begin)
  236.     {
  237.       int r;
  238.  
  239.       i = ((end - begin) / 2) + begin;
  240.       if (i == last_search)
  241.     break;
  242.  
  243.       if (hostname_list[i] &&
  244.       (r = strncmp (hostname_list[i], text, len)) == 0)
  245.     {
  246.       while (strncmp (hostname_list[i], text, len) == 0 && i) i--;
  247.       if (strncmp (hostname_list[i], text, len) != 0) i++;
  248.  
  249.       begin = i;
  250.       while (hostname_list[i] &&
  251.          strncmp (hostname_list[i], text, len) == 0) i++;
  252.       end = i;
  253.  
  254.       result = (char **)xmalloc ((1 + (end - begin)) * sizeof (char *));
  255.       for (i = 0; i + begin < end; i++)
  256.         result[i] = hostname_list[begin + i];
  257.       result[i] = (char *)NULL;
  258.       return (result);
  259.     }
  260.  
  261.       last_search = i;
  262.  
  263.       if (r < 0)
  264.     begin = i;
  265.       else
  266.     end = i;
  267.     }
  268.   return ((char **)NULL);
  269. }
  270.  
  271. /* This is a ksh-style insert-last-arg function.  The difference is that bash
  272.    puts stuff into the history file before expansion and file name generation,
  273.    so we deal with exactly what the user typed.  Those wanting the other
  274.    behavior, at least for the last arg, can use `$_'.  This also `knows' about
  275.    how rl_yank_nth_arg treats `$'. */
  276. insert_last_arg(count, c)
  277.      int count, c;
  278. {
  279.   extern int rl_explicit_arg;
  280.  
  281.   if